Peripheral devices were originally created to enable a user (i.e., human being) to interact with a computing device (e.g., desktop and laptop computers), and vice versa. Peripheral devices were designed to receive instructions from a user, in the form of an input, and to send the input to a computing device, which then translates the input into a meaningful format that can be used by one or more software or hardware components to produce an output. For example, a user might enter a series of keystrokes on a keyboard that is connected to the computing device, and a monitor connected to the computing device might display letters corresponding to the keystrokes entered by the user. The user interacts with the computing device by entering keystrokes on the keyboard and the computing device interacts with the user by displaying letters that correspond to the keystrokes. In order to accomplish this, computing devices use a combination of hardware and software to send and receive instructions to peripheral devices. Some of the hardware used to send and receive instructions includes storage devices (e.g., hard disks), processors, ports (e.g., Universal Serial Bus port), buses (e.g., Peripheral Component Interconnect bus), and controllers (e.g., keyboard controller). Some of the software includes one or more peripheral device drivers (e.g., software used to send and receive instructions between the computing device and peripheral device), and an operating system.
Operating systems communicate with peripheral devices by sending instructions to a device driver that translates the instructions into a format recognizable by a device controller that controls the peripheral devices. The device controller controls the peripheral devices by sending and receiving control signals through ports and/or buses connecting the device controller to the peripheral devices. The operating system determines how the instructions are translated. For example, the output produced by a keyboard when a user is using a Windows operating system may be different from the output produced by a keyboard when a user is using a Linux operating system because the operating systems interpret the keystrokes differently. Similarly, an operating system installed on a mobile computing device (e.g., mobile phones, tablets, and Personal Data Assistants (PDAs)) may not interpret instructions from a device driver the same way an operating system on a non-mobile computing device would interpret the same instructions. For instance, an operating system (e.g., Android mobile OS) installed on a mobile computing device may interpret an input from a keyboard differently from an operating system (e.g., Windows XP) installed on a non-mobile computing device. As a result, a user may not be able to execute the same operations on both operating systems when using the same peripheral device. Therefore, a user is either forced to use a non-mobile computing device for some tasks and a mobile computing device for other tasks, or use different peripheral devices (e.g., printers) that are designed specifically for certain mobile operating systems.
An alternative solution involves creating custom software and hardware solutions that enable a mobile operating system to work with any peripheral device. One approach requires a user to modify (e.g., hack) the mobile operating system running on a mobile computing device to incorporate features from a non-mobile operating system that can interface with a peripheral device. This approach can only be used, however, with open source operating systems (e.g., Android OS). Therefore, mobile computing device manufactures that use non-open operating systems may not provide a user with access to the mobile operating system in order to modify the mobile operating system.
In addition to modifying the software, a user can also create a custom hardware design solution that enables communication between a mobile operating system and software running on a peripheral device. One approach is to create custom peripheral devices that communicate with the mobile operating system using USB On The Go (USB OTG). These solutions, however, often require proprietary and non-standard protocols, thereby limiting their usefulness to particular applications and peripheral pairs.
Furthermore, after communication has been established between the mobile operating system and software running on the peripheral device, a user will have to search for device drivers installed in the mobile operating system that have to be modified to work with the peripheral device. Otherwise, a user will be tasked with developing device drivers that can enable the mobile operating system to work with the peripheral device. In either case, a user may have to spend a considerable amount of time debugging the code they developed to hack the mobile operating system. This could result in the peripheral device or the mobile device malfunctioning. Another problem with this approach is that a user would be required to perform the same procedure for each peripheral device that is not natively supported by their mobile computing device's operating system. Additionally, if a user has more than one mobile computing device, and wants to use one or more peripherals with their other mobile computing devices, the user may have to repeat the same procedure twice for each mobile computing device.
Furthermore, if a user's mobile computing devices are not exactly the same, even if the mobile operating systems are the same, the user may not be able to perform the same procedure when attempting to pair the same peripheral device to different mobile computing devices. For instance, a user might use an Apple™ mobile phone and a HTC™ mobile phone, and may want to use the same keyboard with each mobile phone. The hardware and software needed to make the peripheral device work with both mobile computing devices, however, might not be the same. Thus, a user may be forced to purchase a second keyboard if they are unable to develop the necessary hardware and software solutions to pair the keyboard with the mobile operating system associated with the mobile computing device. This is not a feasible solution for mobile computing device users.
Another issue with the current solution(s) to this problem is that they do not support the interaction between peripheral devices and desktop virtualization technology. For instance, a user accessing a virtual desktop (e.g., Windows operating system) hosted on a server by using an application installed on top of a mobile operating system running on a mobile computing device may encounter issues inputting commands as some of the commands entered by the user do not translate into commands that are normally recognized by the operating system. For example, a user may enter a cut or paste command using a keyboard, and the mobile operating system installed on the user's mobile computing device may not recognize the command, or may instruct the mobile computing device to perform another operation. Because keystrokes can be intercepted by a mobile operating system instead of an operating system running on a virtual desktop, a user may not be able to perform the same operations on a mobile computing device, using the same commands on a mobile computing device that they would on a non-mobile computing device (e.g., laptop or desktop computer). Therefore, the current solutions do not provide users with the ability to use peripheral devices the same way that they would on a non-mobile computing device or the same way that they would use a peripheral device on a mobile computing device connected to a server hosting a virtual desktop.